package first;

import java.util.Arrays;

/**
 * 模拟实现一个简化版的字符串类
 *
 * @author Luke XIE
 * @date 2023/11/16
 */
public class MyString {
    private String value;

    /**
     * 在当前字符串的末尾拼接一个字符串
     *
     * @param str 要追加的字符串
     * @throws NullPointerException 如果传入的字符串为 null
     */
    public void connectionString(String str) {
        // 非空校验
        checkNull(str);
        this.value += str;
    }

    /**
     * 查找子串在当前字符串中的第一次出现的索引位置。
     *
     * @param str 要查找的子串
     * @param <T>       子串的类型（可以是任意类型）
     * @return int 子串在当前字符串中第一次出现的索引位置，如果未找到则返回 -1
     * @throws NullPointerException 如果传入的字符串为 null
     */
    public <T> int indexOf(T str) {
        // 非空校验
        checkNull(str);

        String targetString = str.toString();
        int targetStringLength = targetString.length();
        int currentStringLength = value.length();

        // 如果子串长度大于当前字符串，直接返回-1
        if (targetStringLength > currentStringLength) {
            return -1;
        }

        for (int i = 0; i <= currentStringLength - targetStringLength; i++) {
            // 从当前位置开始，比较子串是否匹配
            if (value.regionMatches(i, targetString, 0, targetStringLength)) {
                // 返回子串在当前字符串中的索引位置
                return i;
            }
        }
        // 未找到子串
        return -1;
    }

    /**
     * 反转字符串中的字符顺序
     *
     * @return String 反转后的字符串
     * @throws NullPointerException 如果当前字符串为 null
     */
    public String reverse() {
        // 非空校验
        checkNull(this.value);

        char[] charArray = this.value.toCharArray();
        int length = charArray.length;

        for (int i = 0; i < length / 2; i++) {
            // 交换首尾字符
            char temp = charArray[i];
            charArray[i] = charArray[length - i - 1];
            charArray[length - i - 1] = temp;
        }

        // 构造反转后的字符串
        return new String(charArray);
    }

    /**
     * 提取字符串的子串
     *
     * @param begin 起始索引（含）
     * @param end   结束索引（不含）
     * @return String 提取出来的子串
     * @throws ArrayIndexOutOfBoundsException 如果下标越界
     * @throws IllegalArgumentException       如果参数非法
     */
    public String substring(int begin, int end) {
        int length = this.value.length();
        if (begin < 0 || end > length) {
            throw new ArrayIndexOutOfBoundsException("下标越界");
        }
        if (begin > end) {
            throw new IllegalArgumentException("非法参数");
        }
        // 如果截取整个字符串直接返回
        if (end - begin == length) {
            return this.value;
        }
        // 截取字串
        char[] currentChar = this.value.toCharArray();
        char[] newChar = Arrays.copyOfRange(currentChar, begin, end);
        return String.valueOf(newChar);
    }

    /**
     * 字符串对比
     *
     * @param str 待比较的字符串
     * @return boolean 比较结果 相同返回true，不同返回false
     */
    public boolean equal(String str) {
        if (str == null) {
            return false;
        }
        if (str.length() != this.value.length()) {
            return false;
        }
        for (int i = 0; i < this.value.length(); i++) {
            if (str.charAt(i) != this.value.charAt(i)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 检查字符串是否为null
     *
     * @param str 待检查的字符串
     * @param <T> 字符串的类型（可以是任意类型）
     * @throws NullPointerException 如果传入的字符串为 null
     */
    public <T> void checkNull(T str) {
        if (str == null) {
            throw new NullPointerException("这是一个null字符串");
        }
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

}
